package com.ftg.learn.chapter01;

import com.ftg.learn.chapter02.Student;
import com.ftg.learn.chapter02.Test;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;

/**
 * @author kangjx
 * @createTime 2022/6/28
 */
public class DynamicArrayDouble {

    /**
     *     原始数组
     */
    private double[] array;

    /**
     * 当前元素所存储的下标
     */
    private int index = 0;

    /**
     *
     */
    private double defaultExpan = 0.5;

    /**
     * 默认的长度
     */
    private final  int defaultCapacity = 10;

    public DynamicArrayDouble(){
    }

    /**
     * 带初始容器大小的构造方法
     * @param capacity  初始长度
     */
    public DynamicArrayDouble(int capacity){
        if(capacity <= 0){
            throw new ArrayIndexOutOfBoundsException("长度不能小于0");
        }
        array = new double[capacity];
    }

    /**
     * 容器初始化
     * @param capacity  长度
     * @param expan     扩容因子
     */
    public DynamicArrayDouble(int capacity, double expan){
        if(capacity <= 0){
            throw new ArrayIndexOutOfBoundsException("长度不能小于0");
        }

        if(0 < expan && 1 > expan){
            throw new ArrayIndexOutOfBoundsException("长度问题");
        }
        this.defaultExpan = expan;
        array = new double[capacity];
    }

    /**
     * 添加操作
     * @param val 真实的值
     */
    public void add(int val){
        //初始化方法 完成数组首次使用时 初始操作
        init();
        //扩容
        scale();
        this.array[index++] = val;
    }

    /**
     * 初始化方法
     */
    public void init(){
        if(Objects.isNull(array)){
            array = new double[defaultCapacity];
        }
        //Comparator
        //Comparable
        //做比较的
//        1 2
//            a b
//                         ascii码
//                    01 --十进制 -- 字母表
//            自然排序
//
    }

    /**
     * 扩容
     */
    public void scale(){
        if(this.array.length == this.index){
            //扩容长度 0.5
//            int newLen = this.array.length + (this.array.length >> 1);
            int newLen = this.array.length + (int)(this.array.length * defaultExpan);
            //是否应该考虑最大值问题
            this.array = Arrays.copyOf(this.array,newLen);
        }
    }

    /**
     * 返回当前动态数组里面全部元素
     * @return
     */
    public double[] getArray(){
        return Arrays.copyOf(this.array,this.index);
    }

    public static void main(String[] args) {
        DynamicArrayDouble d = new DynamicArrayDouble();
        Test.test();

        Comparator<Student> com = new Comparator<Student>(){

            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        };
        Student[] stus = new Student[3];
        Arrays.sort(stus,com);

        Arrays.sort(stus,(o1,o2)->o1.getAge() - o2.getAge());

        Arrays.sort(stus, Comparator.comparingInt(Student::getAge));




//        d.add(23);
//
//        System.out.println(Arrays.toString(d.getArray()));
//        d.add(99);
//
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        d.add(99);
//        System.out.println(Arrays.toString(d.getArray()));
//        d.add(100);
//        System.out.println(Arrays.toString(d.getArray()));
    }

}
